home *** CD-ROM | disk | FTP | other *** search
/ Network PC / Network PC.iso / amiga utilities / disk utilities / backup / backup_restore / backup_src_v3.20.lha / DeviceSelect.c < prev    next >
Encoding:
C/C++ Source or Header  |  1996-06-09  |  8.6 KB  |  385 lines
  1. // DeviceSelect.c
  2. // 09 Jun 1996 12:40:19
  3.  
  4. #ifndef    BACKUP_INCLUDE
  5. #include "IncludeAll.c"
  6. #endif
  7. #include "Backup.h"
  8. #include <gadgets/NoteBook.h>
  9. #include <gadgets/ALVGadget.h>
  10. #include "DeviceSelect.h"
  11. #include "Backup_proto.h"
  12. #include "BackupStrings.h"
  13.  
  14. // #define    d(x)    x
  15. #define    d(x)    ;
  16.  
  17.  
  18. static void BuildDeviceSelect(short Exclude0, enum DevSelExclude Exclude, struct DevSel *ds);
  19. static int DSCompare(const struct DSList *Dsk1, const struct DSList *Dsk2);
  20. static short FindDskIndex(const char *Name);
  21. static void NewDS(struct DevSel *ds, ULONG NewIndex);
  22. static ULONG __interrupt __saveds LVShowDevice(struct Hook *HookPtr,
  23.         struct DSList *DevNode, struct LVDrawMsg *Msg );
  24. static BOOL isDiskDeviceName(const char *DevName);
  25.  
  26.  
  27. // aus Backup.c
  28. extern struct DiskFlags __far *Disks;    // Laufwerks-Liste
  29. extern unsigned short NDisk;        // Anzahl Einträge in Disks[]
  30.  
  31. // aus StringGadgets.c
  32. extern struct Hook StrGadEditHook;
  33.  
  34. // aus Backup_Options.c
  35. extern struct TagItem DS_GTLV_MoreTags[];
  36.  
  37. // aus Backup_Window.c
  38. extern struct Screen *WBScreen;
  39.  
  40.  
  41. static UWORD __chip NoDriveImageData[] =
  42.     {
  43.     0x8001,0x6006,0x1008,0x0810,0x0660,0x0180,0x0180,0x0660,0x0810,0x1008,0x6006,0x8001
  44.     };
  45.  
  46. static UWORD __chip TapeDriveImageData[] =
  47.     {
  48.     31710,40569,32769,36833,36897,48145,48697,46633,48697,39937,32769,32766
  49.     };
  50.  
  51. static UWORD __chip DiskDriveImageData[] =
  52.     {
  53.     65528,49176,49176,49176,49176,49176,49176,65528,57592,59512,59512,65528,0,0,0,
  54.     0,16352,16352,16352,0,7936,5120,5120,0,0,0,0,0,0,0,0,0,0,0,0,0
  55.     };
  56.  
  57. #define    MAX_IMAGE_WIDTH        16
  58. #define    MAX_IMAGE_HEIGHT    12
  59.  
  60. static struct Image NoDriveImage = { 0, 0, 16, 12, 1, NoDriveImageData, 1, 0, NULL };
  61. static struct Image TapeDriveImage = { 0, 0, 16, 12, 1, TapeDriveImageData, 1, 0, NULL };
  62. static struct Image DiskDriveImage = { 0, 0, 13, 12, 3, DiskDriveImageData, 7, 0, NULL };
  63.  
  64.  
  65. struct Hook LVShowDeviceHook = 
  66.     {
  67.     { NULL },
  68.     HookEntry,
  69.     (ULONG (*)()) LVShowDevice,
  70.     NULL
  71.     };
  72.  
  73.  
  74. static short LVTabs[] = { 100, 170, 250, 300, ~0 };
  75.  
  76. static struct DSList *DskPtr = NULL;
  77. static struct Window *DSWin;
  78. static ULONG MarkedIndex;
  79. static ULONG MaxIndex;            // Anzahl Einträge in DskPtr
  80. static struct MinList DriveList;
  81.  
  82. static struct BInputHandler *DSInput = NULL;
  83.  
  84.  
  85. BOOL SetupDeviceSelect(short SelectedIndex, short Exclude0, enum DevSelExclude Exclude, struct DevSel *ds)
  86. {
  87.     BuildDeviceSelect(Exclude0, Exclude, ds);
  88.  
  89.     SetSelectedDevice(SelectedIndex, ds);
  90.  
  91.     // Abstand im ListView so festlegen, daß mindestens 1 Zeile zwischen den Images frei bleibt
  92.     DS_GTLV_MoreTags[0].ti_Data = max(0, (1 + MAX_IMAGE_HEIGHT) - WBScreen->Font->ta_YSize);
  93.  
  94.     return TRUE;
  95. }
  96.  
  97.  
  98. BOOL RebuildDeviceSelect(short SelectedIndex, short Exclude0, enum DevSelExclude Exclude, struct DevSel *ds)
  99. {
  100.     NB_SetGadgetAttrs(*(ds->dsl_ListView), *(ds->dsl_NoteBook),
  101.             GTLV_Labels, ~0,
  102.             GTLV_Top, 0,
  103.             TAG_END);
  104.  
  105.     BuildDeviceSelect(Exclude0, Exclude, ds);
  106.  
  107.     SetSelectedDevice(SelectedIndex, ds);
  108.  
  109.     NB_SetGadgetAttrs(*(ds->dsl_ListView), *(ds->dsl_NoteBook),
  110.             GTLV_Labels, &ds->dsl_List,
  111.             TAG_END);
  112.  
  113.     return TRUE;
  114. }
  115.  
  116.  
  117. static void BuildDeviceSelect(short Exclude0, enum DevSelExclude Exclude, struct DevSel *ds)
  118. {
  119.     short m, n;
  120.  
  121.     CleanupDeviceSelect(ds);
  122.  
  123.     NewList((struct List *) &ds->dsl_List);
  124.  
  125.     ds->dsl_DskPtr = calloc(sizeof(struct DSList), NDisk);
  126.     if (NULL == ds->dsl_DskPtr)
  127.         {
  128.         alarm(GetString(MSG_OUTOFMEMORY), __FUNC__, "ds->dsl_DskPtr", sizeof(struct DSList) * NDisk);
  129.         myabort(15);
  130.         }
  131.  
  132.     for (ds->dsl_MaxIndex=n=0; n<NDisk; n++)
  133.         {
  134.         m = Disks[n].valid ? n : NO_DRIVE;
  135.  
  136.         if (m != Exclude0 && 
  137.                 (DSX_ExcludeTape != Exclude || NULL == Disks[n].TapeReq) &&
  138.                 (DSX_ExcludeNull != Exclude || Disks[n].valid) )
  139.             {
  140.             ds->dsl_DskPtr[ds->dsl_MaxIndex].Dsk = &Disks[n];
  141.             ds->dsl_DskPtr[ds->dsl_MaxIndex].Index = m;
  142.  
  143.             ds->dsl_MaxIndex++;
  144.             }
  145.         }
  146.  
  147.     // Device-Liste alphabetisch sortieren
  148.     qsort((char *) ds->dsl_DskPtr, ds->dsl_MaxIndex, sizeof(struct DSList), DSCompare);
  149. }
  150.  
  151.  
  152. // Index des momentan ausgewählten Eintrages <SelectedIndex> in <ds> merken
  153. void SetSelectedDevice(short SelectedIndex, struct DevSel *ds)
  154. {
  155.     short n;
  156.  
  157.     ds->dsl_MarkedIndex = ~0;
  158.  
  159.     for (n=0; n<ds->dsl_MaxIndex; n++)
  160.         {
  161.         struct DSList *dsl;
  162.  
  163.         dsl = &ds->dsl_DskPtr[n];
  164.  
  165.         dsl->ds_Node.ln_Name = dsl->Dsk->DOSName;
  166.  
  167.         if (!dsl->Dsk->valid)
  168.             dsl->Image = &NoDriveImage;
  169.         else if (NULL != dsl->Dsk->TapeReq)
  170.             dsl->Image = &TapeDriveImage;
  171.         else if (isDiskDeviceName(dsl->Dsk->DeviceName))
  172.             dsl->Image = &DiskDriveImage;
  173.         else
  174.             dsl->Image = NULL;
  175.  
  176.         dsl->Record.alr_Flags = 0L;
  177.  
  178.         AddTail((struct List *) &ds->dsl_List, &dsl->ds_Node);
  179.  
  180.         if (dsl->Index == SelectedIndex)
  181.             {
  182.             dsl->Record.alr_Flags |= ALRF_SELECTED;
  183.             ds->dsl_MarkedIndex = n;
  184.             }
  185.         }
  186.  
  187. }
  188.  
  189.  
  190. void CleanupDeviceSelect(struct DevSel *ds)
  191. {
  192.     if (ds->dsl_DskPtr)
  193.         {
  194.         free(ds->dsl_DskPtr);
  195.         ds->dsl_DskPtr = NULL;
  196.         ds->dsl_MaxIndex = 0l;
  197.         }
  198. }
  199.  
  200.  
  201. // Vergleichsfunktion für qsort() zum Sortieren der Device-Liste
  202. static int DSCompare(const struct DSList *Dsk1, const struct DSList *Dsk2)
  203. {
  204.     ASSERT_VALID(Dsk1);
  205.     ASSERT_VALID(Dsk2);
  206.  
  207.     return stricmp(Dsk1->Dsk->DOSName, Dsk2->Dsk->DOSName);
  208. }
  209.  
  210.  
  211. // Suchen in DskPtr nach einem Device mit Namen <Name>. Liefert Index wenn gefunden
  212. // oder NO_DRIVE
  213. static short FindDskIndex(const char *Name)
  214. {
  215.     short n;
  216.  
  217.     ASSERT_VALID(Name);
  218.  
  219.     for (n=0; n<MaxIndex; n++)
  220.         {
  221.         if (stricmp(DskPtr[n].Dsk->DOSName, Name) == 0)
  222.             return n;
  223.         }
  224.  
  225.     return NO_DRIVE;
  226. }
  227.  
  228.  
  229. static void NewDS(struct DevSel *ds, ULONG NewIndex)
  230. {
  231.     NB_SetGadgetAttrs(*(ds->dsl_ListView), *(ds->dsl_NoteBook),
  232.             GTLV_Selected, NewIndex,
  233.             GTLV_MakeVisible, NewIndex,
  234.             TAG_END);
  235.  
  236.     ds->dsl_MarkedIndex = NewIndex;
  237. }
  238.  
  239.  
  240. static ULONG __interrupt __saveds LVShowDevice(struct Hook *HookPtr,
  241.         struct DSList *DevNode, struct LVDrawMsg *Msg )
  242. {
  243.     ULONG len, Result = LVCB_UNKNOWN;
  244.  
  245.     if (LV_DRAW == Msg->lvdm_MethodID)
  246.         {
  247.         short FgColor, BgColor;
  248.         char *lp;
  249.         short TextX, x;
  250.         short Height, y;
  251.  
  252.         Height = Msg->lvdm_Bounds.MaxY - Msg->lvdm_Bounds.MinY;
  253.         y = Msg->lvdm_Bounds.MinY + (Height - NoDriveImage.Height) / 2;
  254.  
  255.         switch (Msg->lvdm_State)
  256.             {
  257.         case LVR_NORMAL:
  258.         case LVR_NORMALDISABLED:
  259.             FgColor = Msg->lvdm_DrawInfo->dri_Pens[TEXTPEN];
  260.             BgColor = Msg->lvdm_DrawInfo->dri_Pens[BACKGROUNDPEN];
  261.             break;
  262.         case LVR_SELECTED:
  263.         case LVR_SELECTEDDISABLED:
  264.             FgColor = Msg->lvdm_DrawInfo->dri_Pens[FILLTEXTPEN];
  265.             BgColor = Msg->lvdm_DrawInfo->dri_Pens[FILLPEN];
  266.             break;
  267.             }
  268.  
  269.         SetDrMd(Msg->lvdm_RastPort, JAM1);
  270.         SetAPen(Msg->lvdm_RastPort, BgColor);
  271.         RectFill(Msg->lvdm_RastPort,
  272.             Msg->lvdm_Bounds.MinX, Msg->lvdm_Bounds.MinY,
  273.             Msg->lvdm_Bounds.MaxX, Msg->lvdm_Bounds.MaxY);
  274.  
  275.         SetAPen(Msg->lvdm_RastPort, FgColor);
  276.  
  277.         if (DevNode->Image)
  278.             {
  279.             DrawImage(Msg->lvdm_RastPort, DevNode->Image,
  280.                 Msg->lvdm_Bounds.MinX + (MAX_IMAGE_WIDTH - DevNode->Image->Width) / 2,
  281.                 y + (MAX_IMAGE_HEIGHT - DevNode->Image->Height) / 2);
  282.             }
  283.  
  284.         lp = DevNode->ds_Node.ln_Name;
  285.         TextX = Msg->lvdm_Bounds.MinX + 4 + TapeDriveImage.Width;
  286.         x = 0;
  287.  
  288.         while (lp && *lp)
  289.             {
  290.             struct TextExtent TxtExt;
  291.             char *lpNext;
  292.             size_t MaxLen;
  293.  
  294.             lpNext = strchr(lp, '\t');
  295.             MaxLen = lpNext ? lpNext - lp : strlen(lp);
  296.  
  297.             Move(Msg->lvdm_RastPort, TextX + x,
  298.                 Msg->lvdm_Bounds.MinY + Msg->lvdm_RastPort->Font->tf_Baseline);
  299.  
  300.             len = TextFit(Msg->lvdm_RastPort,
  301.                 lp, MaxLen,
  302.                 &TxtExt, NULL, 1,
  303.                 Msg->lvdm_Bounds.MaxX - (TextX + x),
  304.                 1 + Msg->lvdm_Bounds.MaxY - Msg->lvdm_Bounds.MinY );
  305.  
  306.             Text(Msg->lvdm_RastPort, lp, len);
  307.  
  308.             if (lpNext)
  309.                 {
  310.                 short n;
  311.  
  312.                 x += TxtExt.te_Width;
  313.                 
  314.                 for (n=0; LVTabs[n] != ~0 && LVTabs[n] < x; )
  315.                     n++;
  316.                 if (~0 != LVTabs[n])
  317.                     x = LVTabs[n];
  318.  
  319.                 lpNext++;    // '\t' überspringen
  320.                 }
  321.  
  322.             lp = lpNext;
  323.             }
  324.  
  325.         if (LVR_NORMALDISABLED == Msg->lvdm_State || LVR_SELECTEDDISABLED == Msg->lvdm_State)
  326.             {
  327.             static USHORT __chip DisabledPattern[] = { 0x4444, 0x1111 };
  328.             struct RastPort rp;
  329.  
  330.             rp = *Msg->lvdm_RastPort;
  331.             SetAfPt(&rp, DisabledPattern, 1);
  332.             SetDrMd(&rp, JAM1);
  333.             SetAPen(&rp, Msg->lvdm_DrawInfo->dri_Pens[TEXTPEN]);
  334.  
  335.             RectFill(&rp, Msg->lvdm_Bounds.MinX,
  336.                 Msg->lvdm_Bounds.MinY,
  337.                 Msg->lvdm_Bounds.MaxX,
  338.                 Msg->lvdm_Bounds.MaxY
  339.                 );
  340.             }
  341.  
  342.         Result = LVCB_OK;
  343.         }
  344.  
  345.     return Result;
  346. }
  347.  
  348.  
  349.  
  350. static BOOL isDiskDeviceName(const char *DevName)
  351. {
  352.     static const char *KnownDiskDevNames[] =
  353.         {
  354.         "trackdisk.device",
  355.         "mfm.device",
  356.         "diskspare.device",
  357.         NULL,
  358.         };
  359.     short n;
  360.  
  361.     for (n=0; KnownDiskDevNames[n]; n++)
  362.         {
  363.         if (0 == strcmp(KnownDiskDevNames[n], DevName))
  364.             return TRUE;
  365.         }
  366.  
  367.     return FALSE;
  368. }
  369.  
  370.  
  371. void SetDevSelFromIndex(ULONG DriveIndex, struct DevSel *ds)
  372. {
  373.     short n;
  374.  
  375.     // Index des momentan ausgewählten Eintrages suchen
  376.     for (n=0; n<ds->dsl_MaxIndex; n++)
  377.         {
  378.         if (ds->dsl_DskPtr[n].Index == DriveIndex)
  379.             {
  380.             ds->dsl_MarkedIndex = n;
  381.             return;
  382.             }
  383.         }
  384. }
  385.